home *** CD-ROM | disk | FTP | other *** search
/ User's Choice Windows CD / User's Choice Windows CD (CMS Software)(1993).iso / windows5 / xwinc100.zip / CONTRIB-.00 / CONTRIB- / contrib / examples / PEX / rd_struct.c < prev    next >
C/C++ Source or Header  |  1991-02-16  |  25KB  |  1,007 lines
  1. /* $XConsortium: rd_struct.c,v 5.2 91/02/16 09:32:39 rws Exp $ */
  2.  
  3. /***********************************************************
  4. Copyright 1989, 1990, 1991 by Sun Microsystems, Inc. and the X Consortium.
  5.  
  6.             All Rights Reserved
  7.  
  8. Permission to use, copy, modify, and distribute this software and its 
  9. documentation for any purpose and without fee is hereby granted, 
  10. provided that the above copyright notice appear in all copies and that
  11. both that copyright notice and this permission notice appear in 
  12. supporting documentation, and that the names of Sun Microsystems,
  13. the X Consortium, and MIT not be used in advertising or publicity 
  14. pertaining to distribution of the software without specific, written 
  15. prior permission.  
  16.  
  17. SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
  18. INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT 
  19. SHALL SUN MICROSYSTEMS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
  20. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  21. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  22. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  23. SOFTWARE.
  24.  
  25. ******************************************************************/
  26.  
  27. #include <stdio.h>
  28. #include <phigs/phigs.h>
  29. #include <X11/Xlib.h>
  30. #include <X11/Xatom.h>
  31.  
  32. #define PRINT(msg)    (void) fprintf(stderr,msg)
  33. #define PRINTXY(X,Y) \
  34.     (void) fprintf(stderr,"(%g,%g)",(X),(Y))
  35. #define PRINTXYZ(X,Y,Z) \
  36.     (void) fprintf(stderr,"(%g,%g,%g)",(X),(Y),(Z))
  37. #define PRINTSTR(string) \
  38.     (void) fprintf(stderr,"\"%s\"",string)
  39. #define PRINTNAME(name) \
  40.     (void) fprintf(stderr,"%s",name)
  41. #define PRINTINT(number) \
  42.     (void) fprintf(stderr,"%d",number)
  43. #define PRINTFLOAT(number) \
  44.     (void) fprintf(stderr,"%g",number)
  45. #define PRINTINTPAIR(X,Y) \
  46.     (void) fprintf(stderr,"{%d,%d}",(X),(Y))
  47. #define OPEN_BRACKET    (void) fprintf(stderr,"{")
  48. #define CLOSE_BRACKET    (void) fprintf(stderr,"}")
  49. #define COMMA (void) fprintf(stderr,",")
  50. #define ADD_COMMA_IF_NOT_LAST(i,limit) \
  51.     if (i < limit) (void) fprintf(stderr, ",") 
  52.  
  53. typedef void Print_status;
  54. typedef Print_status (*Print_func)();
  55.  
  56. void read_struct();
  57.  
  58. static Print_status print_nothing();
  59. static Print_status print_pointlst3();
  60. static Print_status print_pointlst();
  61. static Print_status print_text3();
  62. static Print_status print_tx();
  63. static Print_status print_atx3();
  64. static Print_status print_atx();
  65. static Print_status print_point();
  66. static Print_status print_fas3();
  67. static Print_status print_fas();
  68. static Print_status print_ca3();
  69. static Print_status print_ca();
  70. static Print_status print_idata();
  71. static Print_status print_fdata();
  72. static Print_status print_txprec();
  73. static Print_status print_vector();
  74. static Print_status print_txpath();
  75. static Print_status print_txalign();
  76. static Print_status print_interstyle();
  77. static Print_status print_edgef();
  78. static Print_status print_linetype();
  79. static Print_status print_markertype();
  80. static Print_status print_pat();
  81. static Print_status print_annotationstyle();
  82. static Print_status print_intlst();
  83. static Print_status print_asf();
  84. static Print_status print_mtran3();
  85. static Print_status print_mtran();
  86. static Print_status print_matrix3();
  87. static Print_status print_matrix();
  88. static Print_status print_mclip3();
  89. static Print_status print_mclip();
  90. static Print_status print_clip();
  91. static Print_status print_data();
  92. static Print_status print_hlhsrid();
  93. static Print_status print_colour();
  94.  
  95. static Print_func print_func[] = {
  96.     print_nothing,
  97.     print_pointlst3,
  98.     print_pointlst,
  99.     print_pointlst3,
  100.     print_pointlst,
  101.     print_text3,
  102.     print_tx,
  103.     print_atx3,
  104.     print_atx,
  105.     print_pointlst3,
  106.     print_pointlst,
  107.     print_fas3,
  108.     print_fas,
  109.     print_ca3,
  110.     print_ca,
  111.     print_nothing, /* pgpd3 */
  112.     print_nothing, /* pgpd */
  113.     print_idata, /* pset_line_ind */
  114.     print_idata, /* pset_marker_ind */
  115.     print_idata, /* pset_text_ind */
  116.     print_idata, /* pset_int_ind */
  117.     print_idata, /* pset_edge_ind */
  118.     print_linetype, /* pset_linetype */
  119.     print_fdata,  /* pset_linewidth */
  120.     print_idata, /* pset_line_colr_ind */
  121.     print_markertype, /* pset_marker_type */
  122.     print_fdata, /* pset_marker_size */
  123.     print_idata, /* pset_marker_colr_ind */
  124.     print_idata, /* pset_text_font */
  125.     print_txprec, /* pset_text_prec */
  126.     print_fdata, /* psetcharexp */
  127.     print_fdata, /* psetcharspacing */
  128.     print_idata, /* pset_text_colr_ind */
  129.     print_fdata, /* pset_char_ht */
  130.     print_vector, /* pset_char_up_vec */
  131.     print_txpath, /* pset_text_path */
  132.     print_txalign, /* pset_text_align */
  133.     print_fdata, /* pset_anno_char_ht */
  134.     print_vector,
  135.     print_txpath,
  136.     print_txalign,
  137.     print_annotationstyle, /* setannotationstyle */
  138.     print_interstyle,
  139.     print_idata,
  140.     print_idata,
  141.     print_edgef,
  142.     print_linetype,
  143.     print_fdata,
  144.     print_idata,
  145.     print_point,
  146.     print_pat,
  147.     print_point,
  148.     print_intlst, /* padd_names_set */
  149.     print_intlst, /* premove_names_set */
  150.     print_asf, 
  151.     print_hlhsrid, /* pset_hlhsr_id */
  152.     print_mtran3,
  153.     print_mtran,
  154.     print_matrix3,
  155.     print_matrix,
  156.     print_mclip3,
  157.     print_mclip,
  158.     print_clip,
  159.     print_nothing,
  160.     print_idata, /* pset_view_ind */
  161.     print_idata, /* plabel */
  162.     print_idata, /* pexec_struct */
  163.     print_data, /* pappl_data */
  164.     print_nothing, /* pgse */
  165.     print_idata, /* pset_pick_id */
  166.     print_nothing, /* ppolylineset3data */
  167.     print_nothing, /* pfill_area3data */
  168.     print_nothing, /* pfill_area_set3data */
  169.     print_nothing, /* ptri3data */
  170.     print_nothing, /* pquad3data */
  171.     print_nothing, /* ppolyhedron3data */
  172.     print_nothing, /* pnunibspcurv */
  173.     print_nothing, /* pnunibspsurf ? */
  174.     print_nothing, /* ext. cell array3 */
  175.     print_colour, /* psettextcolour */
  176.     print_colour, /* psetmarkercolour */
  177.     print_colour, /* psetedgecolour */
  178.     print_colour, /* psetlinecolour */
  179.     print_nothing, /* setcurvapprox */
  180.     print_nothing, /* setlineshadmethod */
  181.     print_colour, /* psetintcolour */
  182.     print_colour, /* psetbackintcolour */
  183.     print_interstyle, /* setbackintstyle */
  184.     print_idata, /* setbackintstyleind */
  185.     print_nothing, /* setareaprop */
  186.     print_nothing, /* setbackareaprop */
  187.     print_nothing, /* setintshadmethod */
  188.     print_nothing, /* setbackintshadmethod */
  189.     print_nothing, /* setintreflecteq */
  190.     print_nothing, /* setbackintreflecteq */
  191.     print_nothing, /* PELEM_SURF_APPROX_CRIT */
  192.     print_nothing, /* PEL_TRIM_CURVE_APPROX_CRITERIA */
  193.     print_nothing, /* setfacedistgmode */
  194.     print_nothing, /* setfacecullmode */
  195.     print_nothing, /* setlightsrcstate */
  196.     print_idata, /* setdcueind */
  197.     print_nothing, /* PEL_COLR_MAPPING_IND */
  198.     print_nothing, /* setcolourmodel */
  199.     print_nothing
  200. };
  201.  
  202. static char *oc_names[] = {
  203.     "Nil",
  204.     "Polyline 3",
  205.     "Polyline",
  206.     "PolyMarker 3",
  207.     "PolyMarker",
  208.     "Text 3",
  209.     "Text",
  210.     "ANNOTATION_TEXT3",
  211.     "ANNOTATION_TEXT",
  212.     "Fill Area 3",
  213.     "Fill Area",
  214.     "Fill Area Set 3",
  215.     "Fill Area Set",
  216.     "Cell Array 3",
  217.     "Cell Array",
  218.     "Generalized Drawing Primitive 3",
  219.     "Generalized Drawing Primitive",
  220.     "Polyline Index",
  221.     "Polymarker Index",
  222.     "Text Index",
  223.     "Interior Index",
  224.     "Edge Index",
  225.     "LINE_TYPE",
  226.     "LINE_WIDTH",
  227.     "LINE_COLOUR_INDEX",
  228.     "MARKER_TYPE",
  229.     "MARKER_SIZE",
  230.     "MARKER_COLOR_INDEX",
  231.     "TEXT_FONT",
  232.     "TEXT_PREC",
  233.     "CHAR_EXP",
  234.     "CHAR_SPACE",
  235.     "TEXT_COLOUR_INDEX",
  236.     "CHAR_HEIGHT",
  237.     "CHAR_UP_VECTOR",
  238.     "TEXT_PATH",
  239.     "TEXT_ALIGN",
  240.     "ANNO_TEXT_CHAR_HEIGHT",
  241.     "ANNO_TEXT_CHAR_UP_VECTOR",
  242.     "Annotation Text Path",
  243.     "Annotation Text Alignment",
  244.     "Annotation Style",
  245.     "INTERIOR_STYLE",
  246.     "Interior Style Index",
  247.     "Interior Style Colour Index",
  248.     "Edge Flag",
  249.     "Edge Type",
  250.     "Edge Width Scale Factor",
  251.     "Edge Colour Index",
  252.     "Pattern Size",
  253.     "Pattern Reference Point and Vectors",
  254.     "Pattern Reference Point",
  255.     "Add Names To Set",
  256.     "Remove Names From Set",
  257.     "Individual Asf",
  258.     "Hlhsr Identifier",
  259.     "Local Modelling Transformation 3",
  260.     "Local Modelling Transformation",
  261.     "Global Modelling Transformation 3",
  262.     "Global Modelling Transformation",
  263.     "Modelling Clipping Volume 3",
  264.     "Modelling Clipping Volume",
  265.     "Modelling Clipping Indicator",
  266.     "Restore Modelling Clipping Volume",
  267.     "View Index",
  268.     "Execute Structure",
  269.     "Label",
  270.     "Application Data",
  271.     "Generalize Structure Element",
  272.     "Pick ID",
  273.     "Polyline Set 3 With Data",
  274.     "Fill Area 3 With Data",
  275.     "Fill Area Set With Data",
  276.     "Triangle Strip 3 With Data",
  277.     "Quad Mesh 3 With Data",
  278.     "Polyhedron 3 With Data",
  279.     "NURB Curve",
  280.     "NURB Surface",
  281.     "Extended Cell Array 3",
  282.     "Text Colour",
  283.     "MARKER_COLOUR",
  284.     "Edge Colour",
  285.     "Polyline Colour",
  286.     "Curve Approximation Criteria",
  287.     "Polyline Shading Method",
  288.     "Interior Colour",
  289.     "Back Interior Colour",
  290.     "Back Interior Style",
  291.     "Back Interior Style Index",
  292.     "Area Properties",
  293.     "Back Area Properties",
  294.     "Interior Shading Method",
  295.     "Back Interior Shading Method",
  296.     "Interior Reflectance Equation",
  297.     "Back Interior Reflectance Equation",
  298.     "Surface Approximation Criteria",
  299.     "Trim Curve Approximation Criteria",
  300.     "Face Distinguishing Mode",
  301.     "Face Culling Mode",
  302.     "Light Source State",
  303.     "DEPTHCUE_INDEX",
  304.     "Colour Mapping Index",
  305.     "Rendering Colour Model"
  306. };
  307.  
  308. static char *linetypes[] = {
  309.     "",
  310.     "PLINE_SOLID",
  311.     "PLINE_DASH",
  312.     "PLINE_DOT",
  313.     "PLINE_DOT_DASH"
  314. };
  315.  
  316. static char *markertypes[] = {
  317.     "",
  318.     "PMARKER_DOT",
  319.     "PMARKER_PLUS",
  320.     "PMARKER_ASTERISK",
  321.     "PMARKER_CIRCLE",
  322.     "PMARKER_CROSS"
  323. };
  324.  
  325. static char *txprec[] = {
  326.     "PPREC_STRING",
  327.     "PPREC_CHAR",
  328.     "PPREC_STROKE"
  329. };
  330.  
  331. static char *txpath[] = {
  332.     "PPATH_RIGHT",
  333.     "PPATH_LEFT",
  334.     "PPATH_UP",
  335.     "PPATH_DOWN"
  336. };
  337.  
  338. static char *txhor[] = {
  339.     "PHOR_NORM",
  340.     "PHOR_LEFT",
  341.     "PHOR_CTR",
  342.     "PHOR_RIGHT"
  343. };
  344.  
  345. static char *txver[] = {
  346.     "PVERT_NORM",
  347.     "PVERT_TOP",
  348.     "PVERT_CAP",
  349.     "PVERT_HALF",
  350.     "PVERT_BASE",
  351.     "PVERT_BOTTOM"
  352. };
  353.  
  354. static char *edgeflags[] = {
  355.     "PEDGE_OFF",
  356.     "PEDGE_ON"
  357. };
  358.  
  359. static char *interstyle[] = {
  360.     "PSTYLE_HOLLOW",
  361.     "PSTYLE_SOLID",
  362.     "PSTYLE_PAT",
  363.     "PSTYLE_HATCH",
  364.     "PSTYLE_EMPTY",
  365.     "PGENERAL"
  366. };
  367.  
  368. static char *annotationstyle[] = {
  369.     "",
  370.     "PANNO_STYLE_UNCONNECTED",
  371.     "PANNO_STYLE_LEAD_LINE"
  372. };
  373.  
  374. static char *attrid [] = {
  375.     "PASPECT_LINETYPE",
  376.     "PASPECT_LINEWIDTH",
  377.     "PASPECT_LINE_COLR_IND",
  378.     "PASPECT_MARKERTYPE",
  379.     "PASPECT_MARKERSIZE",
  380.     "PASPECT_MARKER_COLR_IND",
  381.     "PASPECT_TEXT_FONT",
  382.     "PASPECT_TEXT_PREC",
  383.     "PASPECT_CHAR_EXPAN",
  384.     "PASPECT_CHAR_SPACE",
  385.     "PASPECT_TEXT_COLR_IND",
  386.     "PASPECT_INT_STYLE",
  387.     "PASPECT_INT_STYLE_IND",
  388.     "PASPECT_INT_COLR_IND",
  389.     "PASPECT_EDGE_FLAG",
  390.     "PASPECT_EDGETYPE",
  391.     "PASPECT_EDGEWIDTH",
  392.     "PASPECT_EDGE_COLR_IND",
  393.     "PASPECT_CURVE_APPROX_CRIT",
  394.     "PASPECT_SURF_APPROX_CRIT",
  395.     "PTRIMMING_CURVE_APPROXIMATION_CRITERIA",
  396.     "PASPECT_LINE_SHAD_METH",
  397.     "PASPECT_REFL_PROPS",
  398.     "PASPECT_INT_REFL_EQN",
  399.     "PASPECT_INT_SHAD_METH",
  400.     "PASPECT_BACK_INT_STYLE",
  401.     "PASPECT_BACK_INT_STYLE_IND",
  402.     "PASPECT_BACK_INT_COLR",
  403.     "PASPECT_BACK_REFL_PROPS",
  404.     "PASPECT_BACK_INT_REFL_EQN",
  405.     "PASPECT_BACK_INT_SHAD_METH"
  406. };
  407.  
  408. static char *asf[] =  {
  409.     "PASF_BUNDLED",
  410.     "PASF_INDIV"
  411. };
  412.  
  413. static char *hlhsrid[] = {
  414.     "PHIGS_HLHSR_ID_NONE",
  415.     "PHIGS_HLHSR_ID_ZBUFF"
  416. };
  417.  
  418. static char *clip[] = {
  419.     "PIND_CLIP",
  420.     "PIND_NO_CLIP"
  421. };
  422.  
  423. static char *operator[] = {
  424.     "PMC_REPLACE",
  425.     "PMC_INTERSECT"
  426. };
  427.  
  428. static char *comptype[] = {
  429.     "PTYPE_PRECONCAT",
  430.     "PTYPE_POSTCONCAT",
  431.     "PTYPE_REPLACE"
  432. };
  433.  
  434. static Print_status
  435. print_nothing(el_data)
  436. register Pelem_data *el_data;
  437. {
  438. }
  439.  
  440. static Print_status
  441. print_idata(el_data)
  442. register Pelem_data *el_data;
  443. {
  444.     PRINTINT(el_data->int_data);
  445. }
  446.  
  447. static Print_status
  448. print_fdata(el_data)
  449. register Pelem_data *el_data;
  450. {
  451.     PRINTFLOAT(el_data->float_data);
  452. }
  453.  
  454. static Print_status
  455. print_intlst(el_data)
  456. register Pelem_data *el_data;
  457. {
  458.     register long i;
  459.     register Pint limit = el_data->names.num_ints;
  460.  
  461.     OPEN_BRACKET;
  462.     PRINTINT(limit);
  463.     COMMA;
  464.     OPEN_BRACKET;
  465.     for (i = 0; i < limit; i++) {
  466.         PRINTINT(el_data->names.ints[i]);
  467.         ADD_COMMA_IF_NOT_LAST(i,limit - 1); 
  468.     }
  469.     CLOSE_BRACKET;
  470.     CLOSE_BRACKET;
  471. }
  472.  
  473. static Print_status
  474. print_pointlst3(el_data)
  475. register Pelem_data *el_data;
  476. {
  477.     register long i;
  478.     register Pint limit = el_data->point_list3.num_points;
  479.  
  480.     for (i = 0; i < el_data->point_list3.num_points; i++) {
  481.     PRINTXYZ(el_data->point_list3.points[i].x,
  482.     el_data->point_list3.points[i].y,el_data->point_list3.points[i].z); 
  483.     ADD_COMMA_IF_NOT_LAST(i,limit - 1); 
  484.     }
  485. }
  486.  
  487. static Print_status
  488. print_pointlst(el_data)
  489. register Pelem_data *el_data;
  490. {
  491.     register long i;
  492.     register Pint limit = el_data->point_list.num_points;
  493.  
  494.     for (i = 0; i < el_data->point_list.num_points; i++) {
  495.     PRINTXY(el_data->point_list.points[i].x,el_data->point_list.points[i].y); 
  496.     ADD_COMMA_IF_NOT_LAST(i,limit - 1); 
  497.     }
  498. }
  499.  
  500. static Print_status
  501. print_text3(el_data)
  502. register Pelem_data *el_data;
  503. {
  504.     PRINTXYZ(el_data->text3.pos.x,el_data->text3.pos.y,
  505.     el_data->text3.pos.z);
  506.  
  507.     OPEN_BRACKET;
  508.  
  509.     PRINTXYZ(el_data->text3.dir[0].delta_x,el_data->text3.dir[0].delta_y,
  510.     el_data->text3.dir[0].delta_z);
  511.  
  512.     COMMA;
  513.  
  514.     PRINTXYZ(el_data->text3.dir[1].delta_x,el_data->text3.dir[1].delta_y,
  515.     el_data->text3.dir[1].delta_z);
  516.  
  517.     CLOSE_BRACKET;
  518.  
  519.     PRINTSTR(el_data->text3.char_string);
  520. }
  521.  
  522. static Print_status
  523. print_tx(el_data)
  524. register Pelem_data *el_data;
  525. {
  526.     PRINTXY(el_data->text.pos.x,el_data->text.pos.y);
  527.  
  528.     COMMA;
  529.  
  530.     PRINTSTR(el_data->text.char_string);
  531. }
  532.  
  533. static Print_status
  534. print_atx3(el_data)
  535. register Pelem_data *el_data;
  536. {
  537.     PRINTXYZ(el_data->anno_text_rel3.ref_point.x,el_data->anno_text_rel3.ref_point.y,
  538.     el_data->anno_text_rel3.ref_point.z);
  539.  
  540.     COMMA;
  541.  
  542.     PRINTXYZ(el_data->anno_text_rel3.offset.delta_x,
  543.         el_data->anno_text_rel3.offset.delta_y,
  544.         el_data->anno_text_rel3.offset.delta_z);
  545.  
  546.     COMMA;
  547.  
  548.     PRINTSTR(el_data->anno_text_rel3.char_string);
  549. }
  550.  
  551. static Print_status
  552. print_atx(el_data)
  553. register Pelem_data *el_data;
  554. {
  555.     PRINTXY(el_data->anno_text_rel.ref_point.x,el_data->anno_text_rel.ref_point.y);
  556.  
  557.     COMMA;
  558.  
  559.     PRINTXY(el_data->anno_text_rel.offset.delta_x,el_data->anno_text_rel.offset.delta_y);
  560.  
  561.     COMMA;
  562.  
  563.     PRINTSTR(el_data->anno_text_rel.char_string);
  564. }
  565.  
  566. static Print_status
  567. print_fas3(el_data)
  568. register Pelem_data *el_data;
  569. {
  570.     register long i,j;
  571.  
  572.     PRINTINT(el_data->fill_area_set3.num_point_lists);
  573.  
  574.     COMMA;
  575.  
  576.     for (i = 0; i < el_data->fill_area_set3.num_point_lists; i++) {
  577.     OPEN_BRACKET;
  578.     PRINTINT(el_data->fill_area_set3.point_lists[i].num_points); 
  579.     COMMA;
  580.     for (j = 0; j < el_data->fill_area_set3.point_lists[i].num_points; j++) {
  581.         PRINTXYZ(el_data->fill_area_set3.point_lists[i].points[j].x,
  582.         el_data->fill_area_set3.point_lists[i].points[j].y,
  583.         el_data->fill_area_set3.point_lists[i].points[j].z);
  584.         ADD_COMMA_IF_NOT_LAST(j,el_data->fill_area_set3.point_lists[i].num_points - 1);
  585.     }
  586.     CLOSE_BRACKET;
  587.     }
  588. }
  589.  
  590. static Print_status
  591. print_fas(el_data)
  592. register Pelem_data *el_data;
  593. {
  594.     register long i,j;
  595.  
  596.     PRINTINT(el_data->fill_area_set.num_point_lists);
  597.  
  598.     COMMA;
  599.  
  600.     for (i = 0; i < el_data->fill_area_set.num_point_lists; i++) {
  601.     OPEN_BRACKET;
  602.     PRINTINT(el_data->fill_area_set.point_lists[i].num_points); 
  603.     COMMA;
  604.     for (j = 0; j < el_data->fill_area_set.point_lists[i].num_points; j++) {
  605.         PRINTXY(el_data->fill_area_set.point_lists[i].points[j].x,
  606.         el_data->fill_area_set.point_lists[i].points[j].y);
  607.         ADD_COMMA_IF_NOT_LAST(j,el_data->fill_area_set.point_lists[i].num_points - 1);
  608.     }
  609.     CLOSE_BRACKET;
  610.     }
  611. }
  612.  
  613. static Print_status
  614. print_ca3(el_data)
  615. register Pelem_data *el_data;
  616. {
  617.     register long i;
  618.     Pint x_dim = el_data->cell_array3.dim.size_x;
  619.     Pint y_dim = el_data->cell_array3.dim.size_y;
  620.     Pint num_indices = x_dim * y_dim;
  621.  
  622.     OPEN_BRACKET;
  623.     PRINTXYZ(el_data->cell_array3.paral.p.x,
  624.      el_data->cell_array3.paral.p.y,
  625.      el_data->cell_array3.paral.p.z);
  626.     ADD_COMMA_IF_NOT_LAST(0,2);
  627.     PRINTXYZ(el_data->cell_array3.paral.q.x,
  628.      el_data->cell_array3.paral.q.y,
  629.      el_data->cell_array3.paral.q.z);
  630.     ADD_COMMA_IF_NOT_LAST(1,2);
  631.     PRINTXYZ(el_data->cell_array3.paral.r.x,
  632.      el_data->cell_array3.paral.r.y,
  633.      el_data->cell_array3.paral.r.z);
  634.     ADD_COMMA_IF_NOT_LAST(2,2);
  635.     CLOSE_BRACKET;
  636.     COMMA;
  637.     PRINTINTPAIR(x_dim,y_dim);
  638.     COMMA;
  639.     
  640.     OPEN_BRACKET;
  641.     for (i = 0; i < num_indices; i++) {
  642.     PRINTINT(el_data->cell_array3.colr[i]);
  643.     ADD_COMMA_IF_NOT_LAST(i,num_indices - 1);
  644.     }
  645.     CLOSE_BRACKET;
  646. }
  647.  
  648. static Print_status
  649. print_ca(el_data)
  650. register Pelem_data *el_data;
  651. {
  652.     register long i;
  653.     register Pint x_dim = el_data->cell_array.dim.size_x;
  654.     register Pint y_dim = el_data->cell_array.dim.size_y;
  655.     register Pint num_indices = x_dim * y_dim;
  656.  
  657.     OPEN_BRACKET;
  658.     PRINTXY(el_data->cell_array.rect.p.x,
  659.         el_data->cell_array.rect.p.y);
  660.     COMMA;
  661.     PRINTXY(el_data->cell_array.rect.q.x,
  662.         el_data->cell_array.rect.q.y);
  663.     CLOSE_BRACKET;
  664.     COMMA;
  665.     PRINTINTPAIR(x_dim,y_dim);
  666.     COMMA;
  667.     
  668.     OPEN_BRACKET;
  669.     for (i = 0; i < num_indices; i++) {
  670.     PRINTINT(el_data->cell_array.colr[i]);
  671.     ADD_COMMA_IF_NOT_LAST(i,num_indices - 1);
  672.     }
  673.     CLOSE_BRACKET;
  674. }
  675.  
  676. static Print_status
  677. print_linetype(el_data)
  678. register Pelem_data *el_data;
  679. {
  680.     PRINTNAME(linetypes[el_data->int_data]);
  681. }
  682.  
  683. static Print_status
  684. print_markertype(el_data)
  685. register Pelem_data *el_data;
  686. {
  687.     PRINTNAME(markertypes[el_data->int_data]);
  688. }
  689.  
  690. static Print_status
  691. print_txprec(el_data)
  692. register Pelem_data *el_data;
  693. {
  694.     PRINTNAME(txprec[el_data->int_data]);
  695. }
  696.  
  697. static Print_status
  698. print_vector(el_data)
  699. register Pelem_data *el_data;
  700. {
  701.     PRINTXY(el_data->char_up_vec.delta_x,el_data->char_up_vec.delta_y);
  702. }
  703.  
  704. static Print_status
  705. print_txpath(el_data)
  706. register Pelem_data *el_data;
  707. {
  708.     PRINTNAME(txpath[el_data->int_data]);
  709. }
  710.  
  711. static Print_status
  712. print_txalign(el_data)
  713. register Pelem_data *el_data;
  714. {
  715.     OPEN_BRACKET;
  716.     PRINTNAME(txhor[el_data->text_align.hor]);
  717.     COMMA;
  718.     PRINTNAME(txver[el_data->text_align.vert]);
  719.     CLOSE_BRACKET;
  720. }
  721.  
  722. static Print_status
  723. print_interstyle(el_data)
  724. register Pelem_data *el_data;
  725. {
  726.     PRINTNAME(interstyle[el_data->int_style]);
  727. }
  728.  
  729. static Print_status
  730. print_annotationstyle(el_data)
  731. register Pelem_data *el_data;
  732. {
  733.     PRINTNAME(annotationstyle[el_data->int_data]);
  734. }
  735.  
  736. static Print_status
  737. print_edgef(el_data)
  738. register Pelem_data *el_data;
  739. {
  740.     PRINTNAME(edgeflags[el_data->int_data]);
  741. }
  742.  
  743. static Print_status
  744. print_point(el_data)
  745. register Pelem_data *el_data;
  746. {
  747.     PRINTXY(el_data->point.x,el_data->point.y);    
  748. }
  749.  
  750. static Print_status
  751. print_pat(el_data)
  752. register Pelem_data *el_data;
  753. {
  754.     OPEN_BRACKET;
  755.     PRINTXYZ(el_data->pat_ref_point_vecs.ref_point.x,
  756.          el_data->pat_ref_point_vecs.ref_point.y,
  757.          el_data->pat_ref_point_vecs.ref_point.z);
  758.     CLOSE_BRACKET;
  759.     COMMA;
  760.     PRINTXYZ(el_data->pat_ref_point_vecs.ref_vec[0].delta_x,
  761.          el_data->pat_ref_point_vecs.ref_vec[0].delta_y,
  762.          el_data->pat_ref_point_vecs.ref_vec[0].delta_z);
  763.     COMMA;
  764.     PRINTXYZ(el_data->pat_ref_point_vecs.ref_vec[1].delta_x,
  765.          el_data->pat_ref_point_vecs.ref_vec[1].delta_y,
  766.          el_data->pat_ref_point_vecs.ref_vec[1].delta_z);
  767. }
  768.  
  769. static Print_status
  770. print_asf(el_data)
  771. register Pelem_data *el_data;
  772. {
  773.     PRINTNAME(attrid[el_data->asf.id]);
  774.     COMMA;
  775.     PRINTNAME(asf[el_data->asf.source]);
  776. }
  777.  
  778. static Print_status
  779. print_hlhsrid(el_data)
  780. register Pelem_data *el_data;
  781. {
  782.     PRINTNAME(hlhsrid[el_data->int_data]);
  783. }
  784.  
  785. static Print_status
  786. print_mtran3(el_data)
  787. register Pelem_data *el_data;
  788. {
  789.     register long i, j;
  790.  
  791.     PRINTNAME(comptype[el_data->local_tran3.comp]);
  792.     COMMA;
  793.  
  794.     OPEN_BRACKET;
  795.     for (i = 0; i <= 3; i++) {
  796.     OPEN_BRACKET;
  797.     for (j = 0; j <= 3; j++) {
  798.         PRINTFLOAT(el_data->local_tran3.tran[j][i]);
  799.         ADD_COMMA_IF_NOT_LAST(j,3);  
  800.     }
  801.     CLOSE_BRACKET;
  802.     ADD_COMMA_IF_NOT_LAST(i,3);  
  803.     }
  804.     CLOSE_BRACKET;
  805. }
  806.  
  807. static Print_status
  808. print_mtran(el_data)
  809. register Pelem_data *el_data;
  810. {
  811.     register long i, j;
  812.  
  813.     PRINTNAME(comptype[el_data->local_tran.comp]);
  814.     COMMA;
  815.  
  816.     OPEN_BRACKET;
  817.     for (i = 0; i <= 2; i++) {
  818.     OPEN_BRACKET;
  819.     for (j = 0; j <= 2; j++) {
  820.         PRINTFLOAT(el_data->local_tran.tran[j][i]);
  821.         ADD_COMMA_IF_NOT_LAST(j,2);
  822.     }
  823.     CLOSE_BRACKET;
  824.     ADD_COMMA_IF_NOT_LAST(i,2);
  825.     }
  826.     CLOSE_BRACKET;
  827. }
  828.  
  829. static Print_status
  830. print_matrix3(el_data)
  831. register Pelem_data *el_data;
  832. {
  833.     register long i,j;
  834.  
  835.     for (j = 0; j <= 3; j++) {
  836.     OPEN_BRACKET;
  837.     for (i = 0; i <= 3; i++) {
  838.         PRINTFLOAT(el_data->global_tran3[j][i]);
  839.         ADD_COMMA_IF_NOT_LAST(i,3);
  840.     }
  841.     CLOSE_BRACKET;
  842.     ADD_COMMA_IF_NOT_LAST(j,3);
  843.     }
  844. }
  845.  
  846. static Print_status
  847. print_matrix(el_data)
  848. register Pelem_data *el_data;
  849. {
  850.     register long i,j;
  851.  
  852.     for (j = 0; j <= 2; j++) {
  853.     OPEN_BRACKET;
  854.     for (i = 0; i <= 2; i++) {
  855.         PRINTFLOAT(el_data->global_tran[j][i]);
  856.         ADD_COMMA_IF_NOT_LAST(i,2);
  857.     }
  858.     CLOSE_BRACKET;
  859.     ADD_COMMA_IF_NOT_LAST(j,2);
  860.     }
  861. }
  862.  
  863. static Print_status
  864. print_mclip3(el_data)
  865. register Pelem_data *el_data;
  866. {
  867.     register long i;
  868.     register Pint limit = el_data->model_clip3.half_spaces.num_half_spaces;
  869.  
  870.     PRINTNAME(operator[el_data->model_clip3.op]);
  871.     COMMA;
  872.     OPEN_BRACKET;
  873.     PRINTINT(limit);
  874.     COMMA;
  875.     for (i = 0; i < limit; i++) {
  876.     OPEN_BRACKET;
  877.     PRINTXYZ(el_data->model_clip3.half_spaces.half_spaces[i].point.x,
  878.     el_data->model_clip3.half_spaces.half_spaces[i].point.y,
  879.     el_data->model_clip3.half_spaces.half_spaces[i].point.z);
  880.     COMMA;
  881.     PRINTXYZ(el_data->model_clip3.half_spaces.half_spaces[i].norm.delta_x,
  882.     el_data->model_clip3.half_spaces.half_spaces[i].norm.delta_y,
  883.     el_data->model_clip3.half_spaces.half_spaces[i].norm.delta_z);
  884.     CLOSE_BRACKET;    
  885.     ADD_COMMA_IF_NOT_LAST(i,limit);
  886.     }
  887.     CLOSE_BRACKET;
  888. }
  889.  
  890. static Print_status
  891. print_mclip(el_data)
  892. register Pelem_data *el_data;
  893. {
  894.     register long i;
  895.     register Pint limit = el_data->model_clip.half_spaces.num_half_spaces;
  896.  
  897.     PRINTNAME(operator[el_data->model_clip.op]);
  898.     COMMA;
  899.     OPEN_BRACKET;
  900.     PRINTINT(limit);
  901.     COMMA;
  902.     for (i = 0; i < limit; i++) {
  903.     OPEN_BRACKET;
  904.     PRINTXY(el_data->model_clip.half_spaces.half_spaces[i].point.x,
  905.     el_data->model_clip.half_spaces.half_spaces[i].point.y);
  906.     COMMA;
  907.     PRINTXY(el_data->model_clip.half_spaces.half_spaces[i].norm.delta_x,
  908.     el_data->model_clip.half_spaces.half_spaces[i].norm.delta_y);
  909.     CLOSE_BRACKET;    
  910.     ADD_COMMA_IF_NOT_LAST(i,limit);
  911.     }
  912.     CLOSE_BRACKET;
  913. }
  914.  
  915. static Print_status
  916. print_clip(el_data)
  917. register Pelem_data *el_data;
  918. {
  919.     PRINTNAME(clip[el_data->clip_ind]);
  920. }
  921.  
  922. static Print_status
  923. print_data(el_data)
  924. register Pelem_data *el_data;
  925. {
  926.     register long i;
  927.  
  928.     OPEN_BRACKET;
  929.     PRINTINT(el_data->appl_data.size);
  930.     COMMA;
  931.     OPEN_BRACKET;
  932.     for (i = 0; i < el_data->appl_data.size; i++) {
  933.         fprintf(stderr,"%c",el_data->appl_data.data[i]);    
  934.         ADD_COMMA_IF_NOT_LAST(i,el_data->appl_data.size - 1);
  935.     }
  936.     CLOSE_BRACKET;
  937.     CLOSE_BRACKET;
  938. }
  939.  
  940.  
  941. static Print_status
  942. print_colour(el_data)
  943. register Pelem_data *el_data;
  944. {
  945.     switch (el_data->colr.type) {
  946.     case PINDIRECT:
  947.     fprintf(stderr,    "{PINDIRECT,{%d}}", el_data->colr.val.ind);
  948.     break;
  949.     case PMODEL_RGB:
  950.     fprintf(stderr,"{PMODEL_RGB,{%g, %g, %g}}", 
  951.     el_data->colr.val.general.x,
  952.     el_data->colr.val.general.y, 
  953.     el_data->colr.val.general.z);
  954.     break;
  955.     case PMODEL_CIELUV:
  956.     case PMODEL_HSV:
  957.     case PMODEL_HLS:
  958.     default:
  959.     break;
  960.     }
  961. }
  962.  
  963.  
  964. /*
  965.  *    read the structure 
  966.  */
  967. void
  968. read_struct(structlist)
  969. register Pint_list *structlist;
  970. {
  971.     register long i;
  972.  
  973.     Pint elem_num;
  974.     Pint error_ind;
  975.     Pelem_type elem_type;
  976.     Pint size;
  977.     Pelem_data *elem_data;
  978.     Pstore store;
  979.  
  980.     for (i = 0; i < structlist->num_ints; i++) {
  981.     for (elem_num = 1;; elem_num++) {
  982.         pinq_elem_type_size(structlist->ints[i], elem_num,
  983.         &error_ind, &elem_type, &size);
  984.         if (error_ind) {
  985.         (void) fprintf(stderr,
  986.         "%d element(s) in structure %d\n",
  987.         elem_num - 1, structlist->ints[i]);
  988.         return;
  989.         }
  990.  
  991.         pcreate_store (&error_ind, &store);
  992.         if (error_ind) { 
  993.           fprintf (stderr, "ERROR in creating storage for inquiry of structure elements\n");
  994.           exit (1);
  995.         }
  996.         pinq_elem_content(structlist->ints[i], elem_num, store,
  997.               &error_ind, &elem_data);
  998.  
  999.         if (error_ind) break;
  1000.  
  1001.         (void) fprintf(stderr, "%s(",oc_names[elem_type]);
  1002.         print_func[elem_type](elem_data);
  1003.         (void) fprintf(stderr,");\n");
  1004.     }
  1005.     }
  1006. }
  1007.